{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nJZ6PzOv1kEa"
      },
      "source": [
        "# Progressive Distillation for Fast Sampling of Diffusion Models\n",
        "Code and model checkpoints for the <a href=\"https://openreview.net/forum?id=TIdIXIpzhoI\">ICLR 2022 paper</a> by Tim Salimans and Jonathan Ho.\n",
        "\n",
        "Make sure to use a TPU when running this notebook, enabled via Runtime -> Change runtime type -> Hardware accelerator\n",
        "\n",
        "<a href=\"https://colab.research.google.com/github/google-research/google-research/blob/master/diffusion_distillation/diffusion_distillation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
        "\n",
        "**abstract**:\n",
        "Diffusion models have recently shown great promise for generative modeling, outperforming GANs on perceptual quality and autoregressive models at density estimation. A remaining downside is their slow sampling time: generating high quality samples takes many hundreds or thousands of model evaluations. Here we make two contributions to help eliminate this downside: First, we present new parameterizations of diffusion models that provide increased stability when using few sampling steps. Second, we present a method to distill a trained deterministic diffusion sampler, using many steps, into a new diffusion model that takes half as many sampling steps. We then keep progressively applying this distillation procedure to our model, halving the number of required sampling steps each time. On standard image generation benchmarks like CIFAR-10, ImageNet, and LSUN, we start out with state-of-the-art samplers taking as many as 8192 steps, and are able to distill down to models taking as few as 4 steps without losing much perceptual quality; achieving, for example, a FID of 3.0 on CIFAR-10 in 4 steps. Finally, we show that the full progressive distillation procedure does not take more time than it takes to train the original model, thus representing an efficient solution for generative modeling using diffusion at both train and test time.\n",
        "\n",
        "This notebook is intended as an easy way to get started with the Progressive Distillation algorithm. Reproducing the results from the paper exactly can be done using the hyperparameters in the provided config files, but this requires running at a larger scale and for longer than is practical in a notebook. Trained model checkpoints are provided and can be loaded with this notebook."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZY61ORsCImn7"
      },
      "source": [
        "![fid_steps_graph.png]()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "tEj-N-MOPkCV"
      },
      "outputs": [],
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YsY4lIiZV0fn",
        "outputId": "2e6f77e6-540a-426b-e814-27b651933bf0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Selecting previously unselected package libapr1:amd64.\n",
            "(Reading database ... 155335 files and directories currently installed.)\n",
            "Preparing to unpack .../libapr1_1.6.3-2_amd64.deb ...\n",
            "Unpacking libapr1:amd64 (1.6.3-2) ...\n",
            "Selecting previously unselected package libaprutil1:amd64.\n",
            "Preparing to unpack .../libaprutil1_1.6.1-2_amd64.deb ...\n",
            "Unpacking libaprutil1:amd64 (1.6.1-2) ...\n",
            "Selecting previously unselected package libserf-1-1:amd64.\n",
            "Preparing to unpack .../libserf-1-1_1.3.9-6_amd64.deb ...\n",
            "Unpacking libserf-1-1:amd64 (1.3.9-6) ...\n",
            "Selecting previously unselected package libsvn1:amd64.\n",
            "Preparing to unpack .../libsvn1_1.9.7-4ubuntu1_amd64.deb ...\n",
            "Unpacking libsvn1:amd64 (1.9.7-4ubuntu1) ...\n",
            "Selecting previously unselected package subversion.\n",
            "Preparing to unpack .../subversion_1.9.7-4ubuntu1_amd64.deb ...\n",
            "Unpacking subversion (1.9.7-4ubuntu1) ...\n",
            "Setting up libapr1:amd64 (1.6.3-2) ...\n",
            "Setting up libaprutil1:amd64 (1.6.1-2) ...\n",
            "Setting up libserf-1-1:amd64 (1.3.9-6) ...\n",
            "Setting up libsvn1:amd64 (1.9.7-4ubuntu1) ...\n",
            "Setting up subversion (1.9.7-4ubuntu1) ...\n",
            "Processing triggers for libc-bin (2.27-3ubuntu1.3) ...\n",
            "/sbin/ldconfig.real: /usr/local/lib/python3.7/dist-packages/ideep4py/lib/libmkldnn.so.0 is not a symbolic link\n",
            "\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n",
            "A    diffusion_distillation/README.md\n",
            "A    diffusion_distillation/diffusion_distillation.ipynb\n",
            "A    diffusion_distillation/diffusion_distillation\n",
            "A    diffusion_distillation/diffusion_distillation/__init__.py\n",
            "A    diffusion_distillation/diffusion_distillation/checkpoints.py\n",
            "A    diffusion_distillation/diffusion_distillation/config\n",
            "A    diffusion_distillation/diffusion_distillation/config/__init__.py\n",
            "A    diffusion_distillation/diffusion_distillation/config/bedroom128_base.py\n",
            "A    diffusion_distillation/diffusion_distillation/config/bedroom128_distill.py\n",
            "A    diffusion_distillation/diffusion_distillation/config/church128_base.py\n",
            "A    diffusion_distillation/diffusion_distillation/config/church128_distill.py\n",
            "A    diffusion_distillation/diffusion_distillation/config/cifar_base.py\n",
            "A    diffusion_distillation/diffusion_distillation/config/cifar_distill.py\n",
            "A    diffusion_distillation/diffusion_distillation/config/imagenet64_base.py\n",
            "A    diffusion_distillation/diffusion_distillation/config/imagenet64_distill.py\n",
            "A    diffusion_distillation/diffusion_distillation/datasets.py\n",
            "A    diffusion_distillation/diffusion_distillation/dpm.py\n",
            "A    diffusion_distillation/diffusion_distillation/model.py\n",
            "A    diffusion_distillation/diffusion_distillation/requirements.txt\n",
            "A    diffusion_distillation/diffusion_distillation/schedules.py\n",
            "A    diffusion_distillation/diffusion_distillation/unet.py\n",
            "A    diffusion_distillation/diffusion_distillation/utils.py\n",
            "A    diffusion_distillation/fid_steps_graph.png\n",
            "Checked out revision 9777.\n",
            "\u001b[K     |████████████████████████████████| 176 kB 5.3 MB/s \n",
            "\u001b[K     |████████████████████████████████| 77 kB 8.5 MB/s \n",
            "\u001b[K     |████████████████████████████████| 77 kB 7.7 MB/s \n",
            "\u001b[K     |████████████████████████████████| 462 kB 73.7 MB/s \n",
            "\u001b[K     |████████████████████████████████| 136 kB 88.5 MB/s \n",
            "\u001b[K     |████████████████████████████████| 70 kB 11.0 MB/s \n",
            "\u001b[?25h  Building wheel for ml-collections (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
          ]
        }
      ],
      "source": [
        "# Download the diffusion_distillation repository \n",
        "!apt-get -qq install subversion\n",
        "!svn checkout https://github.com/google-research/google-research/trunk/diffusion_distillation\n",
        "!pip install -r diffusion_distillation/diffusion_distillation/requirements.txt --quiet"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "TYae-ZOA1yaj"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import time\n",
        "import requests\n",
        "import functools\n",
        "import jax\n",
        "from jax import config\n",
        "import jax.numpy as jnp\n",
        "import flax\n",
        "from matplotlib import pyplot as plt\n",
        "import numpy as onp\n",
        "import tensorflow.compat.v2 as tf\n",
        "tf.enable_v2_behavior()\n",
        "from diffusion_distillation import diffusion_distillation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JzuoST_735Rc",
        "outputId": "a9f6ee49-3816-45d2-fe0d-02cecc28c801"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "grpc://10.13.106.178:8470\n"
          ]
        }
      ],
      "source": [
        "# configure JAX to use the TPU\n",
        "if 'TPU_DRIVER_MODE' not in globals():\n",
        "  url = 'http://' + os.environ['COLAB_TPU_ADDR'].split(':')[0] + ':8475/requestversion/tpu_driver_nightly'\n",
        "  resp = requests.post(url)\n",
        "  time.sleep(5)\n",
        "  TPU_DRIVER_MODE = 1\n",
        "config.FLAGS.jax_xla_backend = \"tpu_driver\"\n",
        "config.FLAGS.jax_backend_target = \"grpc://\" + os.environ['COLAB_TPU_ADDR']\n",
        "print(config.FLAGS.jax_backend_target) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1-s_VLDLuL6a"
      },
      "source": [
        "## Train a new diffusion model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6YuCpiSO32fW"
      },
      "outputs": [],
      "source": [
        "# create model\n",
        "config = diffusion_distillation.config.cifar_base.get_config()\n",
        "model = diffusion_distillation.model.Model(config)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Qp0iRHeat6V5"
      },
      "outputs": [],
      "source": [
        "# init params \n",
        "state = jax.device_get(model.make_init_state())\n",
        "state = flax.jax_utils.replicate(state)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YAdzcJ1stvZF"
      },
      "outputs": [],
      "source": [
        "# JIT compile training step\n",
        "train_step = functools.partial(model.step_fn, jax.random.PRNGKey(0), True)\n",
        "train_step = functools.partial(jax.lax.scan, train_step)  # for substeps\n",
        "train_step = jax.pmap(train_step, axis_name='batch', donate_argnums=(0,))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vSd8oEdgt160"
      },
      "outputs": [],
      "source": [
        "# build input pipeline\n",
        "total_bs = config.train.batch_size\n",
        "device_bs = total_bs // jax.device_count()\n",
        "train_ds = model.dataset.get_shuffled_repeated_dataset(\n",
        "    split='train',\n",
        "    batch_shape=(\n",
        "        jax.local_device_count(),  # for pmap\n",
        "        config.train.substeps,  # for lax.scan over multiple substeps\n",
        "        device_bs,  # batch size per device\n",
        "    ),\n",
        "    local_rng=jax.random.PRNGKey(0),\n",
        "    augment=True)\n",
        "train_iter = diffusion_distillation.utils.numpy_iter(train_ds)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nEy9LsdhYtsz",
        "outputId": "4afb75ab-4f0f-4785-f9ec-baa8e139741d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'train/gnorm': 1.464990258216858, 'train/loss': 0.3968523442745209}\n",
            "{'train/gnorm': 1.0451922416687012, 'train/loss': 0.23701481521129608}\n",
            "{'train/gnorm': 1.3321584463119507, 'train/loss': 0.1849556267261505}\n",
            "{'train/gnorm': 0.8692127466201782, 'train/loss': 0.15539495646953583}\n",
            "{'train/gnorm': 0.8343032598495483, 'train/loss': 0.15620359778404236}\n",
            "{'train/gnorm': 0.7462563514709473, 'train/loss': 0.13796086609363556}\n",
            "{'train/gnorm': 0.8287917971611023, 'train/loss': 0.14854209125041962}\n",
            "{'train/gnorm': 0.6603997945785522, 'train/loss': 0.13255183398723602}\n",
            "{'train/gnorm': 0.8660920262336731, 'train/loss': 0.1383683979511261}\n",
            "{'train/gnorm': 0.6390635371208191, 'train/loss': 0.12706886231899261}\n"
          ]
        }
      ],
      "source": [
        "# run training\n",
        "for step in range(10):\n",
        "  batch = next(train_iter)\n",
        "  state, metrics = train_step(state, batch)\n",
        "  metrics = jax.device_get(flax.jax_utils.unreplicate(metrics))\n",
        "  metrics = jax.tree_map(lambda x: float(x.mean(axis=0)), metrics)\n",
        "  print(metrics)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PRMGXA_vxXiW"
      },
      "source": [
        "## Distill a trained diffusion model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8NSAchBAvu1q"
      },
      "outputs": [],
      "source": [
        "# create model\n",
        "config = diffusion_distillation.config.cifar_distill.get_config()\n",
        "model = diffusion_distillation.model.Model(config)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y-hzyGfo9Zzl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "13bf8b8e-8e76-4c0e-b8c0-9e4012bfc326"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loading from local copy of GCS file: /temp/download/gresearch/diffusion-distillation/cifar_original\n"
          ]
        }
      ],
      "source": [
        "# load the teacher params\n",
        "model.load_teacher_state(config.distillation.teacher_checkpoint_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lvT6wPP46E5f"
      },
      "outputs": [],
      "source": [
        "# init student state\n",
        "init_params = diffusion_distillation.utils.copy_pytree(model.teacher_state.ema_params)\n",
        "optim = model.make_optimizer_def().create(init_params)\n",
        "state = diffusion_distillation.model.TrainState(\n",
        "    step=model.teacher_state.step,\n",
        "    optimizer=optim,\n",
        "    ema_params=diffusion_distillation.utils.copy_pytree(init_params),\n",
        "    num_sample_steps=model.teacher_state.num_sample_steps//2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "afjP6y2h6jau"
      },
      "outputs": [],
      "source": [
        "# build input pipeline\n",
        "total_bs = config.train.batch_size\n",
        "device_bs = total_bs // jax.device_count()\n",
        "train_ds = model.dataset.get_shuffled_repeated_dataset(\n",
        "    split='train',\n",
        "    batch_shape=(\n",
        "        jax.local_device_count(),  # for pmap\n",
        "        config.train.substeps,  # for lax.scan over multiple substeps\n",
        "        device_bs,  # batch size per device\n",
        "    ),\n",
        "    local_rng=jax.random.PRNGKey(0),\n",
        "    augment=True)\n",
        "train_iter = diffusion_distillation.utils.numpy_iter(train_ds)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1Qnjl_r36jdo",
        "outputId": "d91ccc2a-a34f-4e64-9d1a-89dbc156e618"
      },
      "outputs": [
        {
          "metadata": {
            "tags": null
          },
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "distilling teacher using 8192 sampling steps into student using 4096 steps\n",
            "{'train/gnorm': 2.8683674335479736, 'train/loss': 0.0016302959993481636}\n",
            "{'train/gnorm': 0.2860860824584961, 'train/loss': 0.00021573054254986346}\n",
            "{'train/gnorm': 0.2714298367500305, 'train/loss': 0.0002000583044718951}\n",
            "{'train/gnorm': 0.21906311810016632, 'train/loss': 0.00011645098129520193}\n",
            "{'train/gnorm': 6.853092193603516, 'train/loss': 0.003547081258147955}\n",
            "{'train/gnorm': 0.1784321814775467, 'train/loss': 0.00012405704183038324}\n",
            "{'train/gnorm': 6.246722221374512, 'train/loss': 0.003840960096567869}\n",
            "{'train/gnorm': 0.6847068071365356, 'train/loss': 0.00032937084324657917}\n",
            "{'train/gnorm': 1.5631742477416992, 'train/loss': 0.0009624079684726894}\n",
            "{'train/gnorm': 0.5180217623710632, 'train/loss': 0.00028331097564660013}\n",
            "distilling teacher using 4096 sampling steps into student using 2048 steps\n",
            "{'train/gnorm': 2.5235648155212402, 'train/loss': 0.0019040238112211227}\n",
            "{'train/gnorm': 2.9192070960998535, 'train/loss': 0.002178814494982362}\n",
            "{'train/gnorm': 0.3235483169555664, 'train/loss': 0.00021021410066168755}\n",
            "{'train/gnorm': 1.7350057363510132, 'train/loss': 0.0013401142787188292}\n",
            "{'train/gnorm': 1.2188830375671387, 'train/loss': 0.0007223966531455517}\n",
            "{'train/gnorm': 2.8477327823638916, 'train/loss': 0.0026104548014700413}\n",
            "{'train/gnorm': 0.9699719548225403, 'train/loss': 0.0006435088580474257}\n",
            "{'train/gnorm': 1.4976762533187866, 'train/loss': 0.0009475204860791564}\n",
            "{'train/gnorm': 1.5087296962738037, 'train/loss': 0.0012296756030991673}\n",
            "{'train/gnorm': 1.2266103029251099, 'train/loss': 0.0012048741336911917}\n",
            "distilling teacher using 2048 sampling steps into student using 1024 steps\n",
            "{'train/gnorm': 2.9126031398773193, 'train/loss': 0.002832334255799651}\n",
            "{'train/gnorm': 2.1991543769836426, 'train/loss': 0.0025902255438268185}\n",
            "{'train/gnorm': 1.0590112209320068, 'train/loss': 0.0009463253663852811}\n",
            "{'train/gnorm': 1.1549898386001587, 'train/loss': 0.0008414936019107699}\n",
            "{'train/gnorm': 1.2275892496109009, 'train/loss': 0.0012729756999760866}\n",
            "{'train/gnorm': 0.8981778025627136, 'train/loss': 0.0009795547230169177}\n",
            "{'train/gnorm': 0.6524263620376587, 'train/loss': 0.0004901870852336287}\n",
            "{'train/gnorm': 1.0157272815704346, 'train/loss': 0.0009844127343967557}\n",
            "{'train/gnorm': 0.6009726524353027, 'train/loss': 0.000479473324958235}\n",
            "{'train/gnorm': 0.314603716135025, 'train/loss': 0.0002288076066179201}\n",
            "distilling teacher using 1024 sampling steps into student using 512 steps\n",
            "{'train/gnorm': 0.4539274573326111, 'train/loss': 0.0004989042645320296}\n",
            "{'train/gnorm': 0.7285604476928711, 'train/loss': 0.0007425985531881452}\n",
            "{'train/gnorm': 0.085848867893219, 'train/loss': 6.856630352558568e-05}\n",
            "{'train/gnorm': 0.22456252574920654, 'train/loss': 0.00022025832731742412}\n",
            "{'train/gnorm': 0.29953739047050476, 'train/loss': 0.0002850946329999715}\n",
            "{'train/gnorm': 0.23811647295951843, 'train/loss': 0.0002319964551134035}\n",
            "{'train/gnorm': 0.2970944344997406, 'train/loss': 0.00030811078613623977}\n"
          ]
        }
      ],
      "source": [
        "steps_per_distill_iter = 10  # number of distillation steps per iteration of progressive distillation\n",
        "end_num_steps = 4  # eventual number of sampling steps we want to use \n",
        "while state.num_sample_steps >= end_num_steps:\n",
        "\n",
        "  # compile training step\n",
        "  train_step = functools.partial(model.step_fn, jax.random.PRNGKey(0), True)\n",
        "  train_step = functools.partial(jax.lax.scan, train_step)  # for substeps\n",
        "  train_step = jax.pmap(train_step, axis_name='batch', donate_argnums=(0,))\n",
        "\n",
        "  # train the student against the teacher model\n",
        "  print('distilling teacher using %d sampling steps into student using %d steps'\n",
        "        % (model.teacher_state.num_sample_steps, state.num_sample_steps))\n",
        "  state = flax.jax_utils.replicate(state)\n",
        "  for step in range(steps_per_distill_iter):\n",
        "    batch = next(train_iter)\n",
        "    state, metrics = train_step(state, batch)\n",
        "    metrics = jax.device_get(flax.jax_utils.unreplicate(metrics))\n",
        "    metrics = jax.tree_map(lambda x: float(x.mean(axis=0)), metrics)\n",
        "    print(metrics)\n",
        "\n",
        "  # student becomes new teacher for next distillation iteration\n",
        "  model.teacher_state = jax.device_get(\n",
        "      flax.jax_utils.unreplicate(state).replace(optimizer=None))\n",
        "\n",
        "  # reset student optimizer for next distillation iteration\n",
        "  init_params = diffusion_distillation.utils.copy_pytree(model.teacher_state.ema_params)\n",
        "  optim = model.make_optimizer_def().create(init_params)\n",
        "  state = diffusion_distillation.model.TrainState(\n",
        "      step=model.teacher_state.step,\n",
        "      optimizer=optim,\n",
        "      ema_params=diffusion_distillation.utils.copy_pytree(init_params),\n",
        "      num_sample_steps=model.teacher_state.num_sample_steps//2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7m3bdkYVyqhv"
      },
      "source": [
        "## Load a distilled model checkpoint and sample from it"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rSxjJ5kNS0Kc",
        "outputId": "e7c6225d-f678-41cf-9967-92ea344a88fc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "gs://gresearch/diffusion-distillation/bedroom_1\n",
            "gs://gresearch/diffusion-distillation/bedroom_16\n",
            "gs://gresearch/diffusion-distillation/bedroom_2\n",
            "gs://gresearch/diffusion-distillation/bedroom_32\n",
            "gs://gresearch/diffusion-distillation/bedroom_4\n",
            "gs://gresearch/diffusion-distillation/bedroom_64\n",
            "gs://gresearch/diffusion-distillation/bedroom_8\n",
            "gs://gresearch/diffusion-distillation/bedroom_original\n",
            "gs://gresearch/diffusion-distillation/church_1\n",
            "gs://gresearch/diffusion-distillation/church_16\n",
            "gs://gresearch/diffusion-distillation/church_2\n",
            "gs://gresearch/diffusion-distillation/church_32\n",
            "gs://gresearch/diffusion-distillation/church_4\n",
            "gs://gresearch/diffusion-distillation/church_64\n",
            "gs://gresearch/diffusion-distillation/church_8\n",
            "gs://gresearch/diffusion-distillation/church_original\n",
            "gs://gresearch/diffusion-distillation/cifar_1\n",
            "gs://gresearch/diffusion-distillation/cifar_16\n",
            "gs://gresearch/diffusion-distillation/cifar_2\n",
            "gs://gresearch/diffusion-distillation/cifar_32\n",
            "gs://gresearch/diffusion-distillation/cifar_4\n",
            "gs://gresearch/diffusion-distillation/cifar_64\n",
            "gs://gresearch/diffusion-distillation/cifar_8\n",
            "gs://gresearch/diffusion-distillation/cifar_original\n",
            "gs://gresearch/diffusion-distillation/imagenet_1\n",
            "gs://gresearch/diffusion-distillation/imagenet_16\n",
            "gs://gresearch/diffusion-distillation/imagenet_2\n",
            "gs://gresearch/diffusion-distillation/imagenet_32\n",
            "gs://gresearch/diffusion-distillation/imagenet_4\n",
            "gs://gresearch/diffusion-distillation/imagenet_64\n",
            "gs://gresearch/diffusion-distillation/imagenet_8\n",
            "gs://gresearch/diffusion-distillation/imagenet_original\n"
          ]
        }
      ],
      "source": [
        "# list all available distilled checkpoints\n",
        "!gsutil ls gs://gresearch/diffusion-distillation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "oE3bD54H_8kA"
      },
      "outputs": [],
      "source": [
        "# create imagenet model\n",
        "config = diffusion_distillation.config.imagenet64_base.get_config()\n",
        "model = diffusion_distillation.model.Model(config)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "SHe7jXOdCVLE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4e7c426e-a876-4f58-883b-d76090232df8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "downloading file from GCS: gs://gresearch/diffusion-distillation/imagenet_8\n"
          ]
        }
      ],
      "source": [
        "# load distilled checkpoint for 8 sampling steps\n",
        "loaded_params = diffusion_distillation.checkpoints.restore_from_path('gs://gresearch/diffusion-distillation/imagenet_8', target=None)['ema_params']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "LXYUUxGoFjz8"
      },
      "outputs": [],
      "source": [
        "# fix possible flax version errors\n",
        "ema_params = jax.device_get(model.make_init_state()).ema_params\n",
        "loaded_params = flax.core.unfreeze(loaded_params)\n",
        "loaded_params = jax.tree_map(\n",
        "    lambda x, y: onp.reshape(x, y.shape) if hasattr(y, 'shape') else x,\n",
        "    loaded_params,\n",
        "    flax.core.unfreeze(ema_params))\n",
        "loaded_params = flax.core.freeze(loaded_params)\n",
        "del ema_params"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "Dof1kKgjCcqM"
      },
      "outputs": [],
      "source": [
        "# sample from the model\n",
        "imagenet_classes = {'malamute': 249, 'siamese': 284, 'great_white': 2,\n",
        "                    'speedboat': 814, 'reef': 973, 'sports_car': 817,\n",
        "                    'race_car': 751, 'model_t': 661, 'truck': 867}\n",
        "labels = imagenet_classes['truck'] * jnp.ones((4,), dtype=jnp.int32)\n",
        "samples = model.samples_fn(rng=jax.random.PRNGKey(0), labels=labels, params=loaded_params, num_steps=8)\n",
        "samples = jax.device_get(samples).astype(onp.uint8)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "u-NrZxvn6p0M",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "7efd17a5-7235-4f56-994b-ea9dabab6315"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-0.5, 131.5, 131.5, -0.5)"
            ]
          },
          "metadata": {},
          "execution_count": 16
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# visualize samples\n",
        "padded_samples = onp.pad(samples, ((0,0), (1,1), (1,1), (0,0)), mode='constant', constant_values=255)\n",
        "nrows = int(onp.sqrt(padded_samples.shape[0]))\n",
        "ncols = padded_samples.shape[0]//nrows\n",
        "_, height, width, channels = padded_samples.shape\n",
        "img_grid = padded_samples.reshape(nrows, ncols, height, width, channels).swapaxes(1,2).reshape(height*nrows, width*ncols, channels)\n",
        "img = plt.imshow(img_grid)\n",
        "plt.axis('off')"
      ]
    }
  ],
  "metadata": {
    "accelerator": "TPU",
    "colab": {
      "collapsed_sections": [],
      "name": "diffusion_distillation.ipynb",
      "provenance": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}